/*
 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.org.apache.bcel.internal.classfile;

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache BCEL" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache BCEL", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

import com.sun.org.apache.bcel.internal.Constants;
import com.sun.org.apache.bcel.internal.util.ByteSequence;
import java.io.*;
import java.util.ArrayList;
import java.util.zip.*;

/**
 * Utility functions that do not really belong to any class in particular.
 *
 * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
 */
public abstract class Utility {
    private static int consumed_chars; /* How many chars have been consumed
                                        * during parsing in signatureToString().
                                        * Read by methodSignatureToString().
                                        * Set by side effect,but only internally.
                                        */
    private static boolean wide = false; /* The `WIDE' instruction is used in the
                                          * byte code to allow 16-bit wide indices
                                          * for local variables. This opcode
                                          * precedes an `ILOAD', e.g.. The opcode
                                          * immediately following takes an extra
                                          * byte which is combined with the
                                          * following byte to form a
                                          * 16-bit value.
                                          */

    /**
     * Convert bit field of flags into string such as `static final'.
     *
     * @param  access_flags Access flags
     * @return String representation of flags
     */
    public static final String accessToString(int access_flags) {
        return accessToString(access_flags, false);
    }

    /**
     * Convert bit field of flags into string such as `static final'.
     *
     * Special case: Classes compiled with new compilers and with the
     * `ACC_SUPER' flag would be said to be "synchronized". This is
     * because SUN used the same value for the flags `ACC_SUPER' and
     * `ACC_SYNCHRONIZED'.
     *
     * @param  access_flags Access flags
     * @param  for_class access flags are for class qualifiers ?
     * @return String representation of flags
     */
    public static final String accessToString(int access_flags, boolean for_class) {
        StringBuffer buf = new StringBuffer();

        int p = 0;
        for (int i = 0; p < Constants.MAX_ACC_FLAG; i++) { // Loop through known flags
            p = pow2(i);

            if ((access_flags & p) != 0) {
                /* Special case: Classes compiled with new compilers and with the
                 * `ACC_SUPER' flag would be said to be "synchronized". This is
                 * because SUN used the same value for the flags `ACC_SUPER' and
                 * `ACC_SYNCHRONIZED'.
                 */
                if (for_class && ((p == Constants.ACC_SUPER) || (p == Constants.ACC_INTERFACE)))
                    continue;

                buf.append(Constants.ACCESS_NAMES[i] + " ");
            }
        }

        return buf.toString().trim();
    }

    /**
     * @return "class" or "interface", depending on the ACC_INTERFACE flag
     */
    public static final String classOrInterface(int access_flags) {
        return ((access_flags & Constants.ACC_INTERFACE) != 0) ? "interface" : "class";
    }

    /**
     * Disassemble a byte array of JVM byte codes starting from code line
     * `index' and return the disassembled string representation. Decode only
     * `num' opcodes (including their operands), use -1 if you want to
     * decompile everything.
     *
     * @param  code byte code array
     * @param  constant_pool Array of constants
     * @param  index offset in `code' array
     * <EM>(number of opcodes, not bytes!)</EM>
     * @param  length number of opcodes to decompile, -1 for all
     * @param  verbose be verbose, e.g. print constant pool index
     * @return String representation of byte codes
     */
    public static final String codeToString(byte[] code, ConstantPool constant_pool, int index, int length, boolean verbose) {
        StringBuffer buf = new StringBuffer(code.length * 20); // Should be sufficient
        ByteSequence stream = new ByteSequence(code);

        try {
            for (int i = 0; i < index; i++)
                // Skip `index' lines of code
                codeToString(stream, constant_pool, verbose);

            for (int i = 0; stream.available() > 0; i++) {
                if ((length < 0) || (i < length)) {
                    String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
                    buf.append(indices + codeToString(stream, constant_pool, verbose) + '\n');
                }
            }
        } catch (IOException e) {
            System.out.println(buf.toString());
            e.printStackTrace();
            throw new ClassFormatException("Byte code error: " + e);
        }

        return buf.toString();
    }

    public static final String codeToString(byte[] code, ConstantPool constant_pool, int index, int length) {
        return codeToString(code, constant_pool, index, length, true);
    }

    /**
     * Disassemble a stream of byte codes and return the
     * string representation.
     *
     * @param  bytes stream of bytes
     * @param  constant_pool Array of constants
     * @param  verbose be verbose, e.g. print constant pool index
     * @return String representation of byte code
     */
    public static final String codeToString(ByteSequence bytes, ConstantPool constant_pool, boolean verbose) throws IOException {
        short opcode = (short) bytes.readUnsignedByte();
        int default_offset = 0, low, high, npairs;
        int index, vindex, constant;
        int[] match, jump_table;
        int no_pad_bytes = 0, offset;
        StringBuffer buf = new StringBuffer(Constants.OPCODE_NAMES[opcode]);

        /* Special case: Skip (0-3) padding bytes, i.e., the
         * following bytes are 4-byte-aligned
         */
        if ((opcode == Constants.TABLESWITCH) || (opcode == Constants.LOOKUPSWITCH)) {
            int remainder = bytes.getIndex() % 4;
            no_pad_bytes = (remainder == 0) ? 0 : 4 - remainder;

            for (int i = 0; i < no_pad_bytes; i++) {
                byte b;

                if ((b = bytes.readByte()) != 0)
                    System.err.println("Warning: Padding byte != 0 in " + Constants.OPCODE_NAMES[opcode] + ":" + b);
            }

            // Both cases have a field default_offset in common
            default_offset = bytes.readInt();
        }

        switch (opcode) {
            /* Table switch has variable length arguments.
             */
            case Constants.TABLESWITCH:
                low = bytes.readInt();
                high = bytes.readInt();

                offset = bytes.getIndex() - 12 - no_pad_bytes - 1;
                default_offset += offset;

                buf.append("\tdefault = " + default_offset + ", low = " + low + ", high = " + high + "(");

                jump_table = new int[high - low + 1];
                for (int i = 0; i < jump_table.length; i++) {
                    jump_table[i] = offset + bytes.readInt();
                    buf.append(jump_table[i]);

                    if (i < jump_table.length - 1)
                        buf.append(", ");
                }
                buf.append(")");

                break;

            /* Lookup switch has variable length arguments.
             */
            case Constants.LOOKUPSWITCH: {

                npairs = bytes.readInt();
                offset = bytes.getIndex() - 8 - no_pad_bytes - 1;

                match = new int[npairs];
                jump_table = new int[npairs];
                default_offset += offset;

                buf.append("\tdefault = " + default_offset + ", npairs = " + npairs + " (");

                for (int i = 0; i < npairs; i++) {
                    match[i] = bytes.readInt();

                    jump_table[i] = offset + bytes.readInt();

                    buf.append("(" + match[i] + ", " + jump_table[i] + ")");

                    if (i < npairs - 1)
                        buf.append(", ");
                }
                buf.append(")");
            }
                break;

            /* Two address bytes + offset from start of byte stream form the
             * jump target
             */
            case Constants.GOTO:
            case Constants.IFEQ:
            case Constants.IFGE:
            case Constants.IFGT:
            case Constants.IFLE:
            case Constants.IFLT:
            case Constants.JSR:
            case Constants.IFNE:
            case Constants.IFNONNULL:
            case Constants.IFNULL:
            case Constants.IF_ACMPEQ:
            case Constants.IF_ACMPNE:
            case Constants.IF_ICMPEQ:
            case Constants.IF_ICMPGE:
            case Constants.IF_ICMPGT:
            case Constants.IF_ICMPLE:
            case Constants.IF_ICMPLT:
            case Constants.IF_ICMPNE:
                buf.append("\t\t#" + ((bytes.getIndex() - 1) + bytes.readShort()));
                break;

            /* 32-bit wide jumps
             */
            case Constants.GOTO_W:
            case Constants.JSR_W:
                buf.append("\t\t#" + ((bytes.getIndex() - 1) + bytes.readInt()));
                break;

            /* Index byte references local variable (register)
             */
            case Constants.ALOAD:
            case Constants.ASTORE:
            case Constants.DLOAD:
            case Constants.DSTORE:
            case Constants.FLOAD:
            case Constants.FSTORE:
            case Constants.ILOAD:
            case Constants.ISTORE:
            case Constants.LLOAD:
            case Constants.LSTORE:
            case Constants.RET:
                if (wide) {
                    vindex = bytes.readUnsignedShort();
                    wide = false; // Clear flag
                } else
                    vindex = bytes.readUnsignedByte();

                buf.append("\t\t%" + vindex);
                break;

            /*
             * Remember wide byte which is used to form a 16-bit address in the
             * following instruction. Relies on that the method is called again with
             * the following opcode.
             */
            case Constants.WIDE:
                wide = true;
                buf.append("\t(wide)");
                break;

            /* Array of basic type.
             */
            case Constants.NEWARRAY:
                buf.append("\t\t<" + Constants.TYPE_NAMES[bytes.readByte()] + ">");
                break;

            /* Access object/class fields.
             */
            case Constants.GETFIELD:
            case Constants.GETSTATIC:
            case Constants.PUTFIELD:
            case Constants.PUTSTATIC:
                index = bytes.readUnsignedShort();
                buf.append("\t\t" + constant_pool.constantToString(index, Constants.CONSTANT_Fieldref) + (verbose ? " (" + index + ")" : ""));
                break;

            /* Operands are references to classes in constant pool
             */
            case Constants.NEW:
            case Constants.CHECKCAST:
                buf.append("\t");
            case Constants.INSTANCEOF:
                index = bytes.readUnsignedShort();
                buf.append("\t<" + constant_pool.constantToString(index, Constants.CONSTANT_Class) + ">" + (verbose ? " (" + index + ")" : ""));
                break;

            /* Operands are references to methods in constant pool
             */
            case Constants.INVOKESPECIAL:
            case Constants.INVOKESTATIC:
            case Constants.INVOKEVIRTUAL:
                index = bytes.readUnsignedShort();
                buf.append("\t" + constant_pool.constantToString(index, Constants.CONSTANT_Methodref) + (verbose ? " (" + index + ")" : ""));
                break;

            case Constants.INVOKEINTERFACE:
                index = bytes.readUnsignedShort();
                int nargs = bytes.readUnsignedByte(); // historical, redundant
                buf.append("\t" + constant_pool.constantToString(index, Constants.CONSTANT_InterfaceMethodref) + (verbose ? " (" + index + ")\t" : "") + nargs + "\t" + bytes.readUnsignedByte()); // Last byte is a reserved space
                break;

            /* Operands are references to items in constant pool
             */
            case Constants.LDC_W:
            case Constants.LDC2_W:
                index = bytes.readUnsignedShort();

                buf.append("\t\t" + constant_pool.constantToString(index, constant_pool.getConstant(index).getTag()) + (verbose ? " (" + index + ")" : ""));
                break;

            case Constants.LDC:
                index = bytes.readUnsignedByte();

                buf.append("\t\t" + constant_pool.constantToString(index, constant_pool.getConstant(index).getTag()) + (verbose ? " (" + index + ")" : ""));
                break;

            /* Array of references.
             */
            case Constants.ANEWARRAY:
                index = bytes.readUnsignedShort();

                buf.append("\t\t<" + compactClassName(constant_pool.getConstantString(index, Constants.CONSTANT_Class), false) + ">" + (verbose ? " (" + index + ")" : ""));
                break;

            /* Multidimensional array of references.
             */
            case Constants.MULTIANEWARRAY: {
                index = bytes.readUnsignedShort();
                int dimensions = bytes.readUnsignedByte();

                buf.append("\t<" + compactClassName(constant_pool.getConstantString(index, Constants.CONSTANT_Class), false) + ">\t" + dimensions + (verbose ? " (" + index + ")" : ""));
            }
                break;

            /* Increment local variable.
             */
            case Constants.IINC:
                if (wide) {
                    vindex = bytes.readUnsignedShort();
                    constant = bytes.readShort();
                    wide = false;
                } else {
                    vindex = bytes.readUnsignedByte();
                    constant = bytes.readByte();
                }
                buf.append("\t\t%" + vindex + "\t" + constant);
                break;

            default:
                if (Constants.NO_OF_OPERANDS[opcode] > 0) {
                    for (int i = 0; i < Constants.TYPE_OF_OPERANDS[opcode].length; i++) {
                        buf.append("\t\t");
                        switch (Constants.TYPE_OF_OPERANDS[opcode][i]) {
                            case Constants.T_BYTE:
                                buf.append(bytes.readByte());
                                break;
                            case Constants.T_SHORT:
                                buf.append(bytes.readShort());
                                break;
                            case Constants.T_INT:
                                buf.append(bytes.readInt());
                                break;

                            default: // Never reached
                                System.err.println("Unreachable default case reached!");
                                buf.setLength(0);
                        }
                    }
                }
        }

        return buf.toString();
    }

    public static final String codeToString(ByteSequence bytes, ConstantPool constant_pool) throws IOException {
        return codeToString(bytes, constant_pool, true);
    }

    /**
     * Shorten long class names, <em>java/lang/String</em> becomes
     * <em>String</em>.
     *
     * @param str The long class name
     * @return Compacted class name
     */
    public static final String compactClassName(String str) {
        return compactClassName(str, true);
    }

    /**
     * Shorten long class name <em>str</em>, i.e., chop off the <em>prefix</em>,
     * if the
     * class name starts with this string and the flag <em>chopit</em> is true.
     * Slashes <em>/</em> are converted to dots <em>.</em>.
     *
     * @param str The long class name
     * @param prefix The prefix the get rid off
     * @param chopit Flag that determines whether chopping is executed or not
     * @return Compacted class name
     */
    public static final String compactClassName(String str, String prefix, boolean chopit) {
        int len = prefix.length();

        str = str.replace('/', '.'); // Is `/' on all systems, even DOS

        if (chopit) {
            // If string starts with `prefix' and contains no further dots
            if (str.startsWith(prefix) && (str.substring(len).indexOf('.') == -1))
                str = str.substring(len);
        }

        return str;
    }

    /**
     * Shorten long class names, <em>java/lang/String</em> becomes
     * <em>java.lang.String</em>,
     * e.g.. If <em>chopit</em> is <em>true</em> the prefix <em>java.lang</em>
     * is also removed.
     *
     * @param str The long class name
     * @param chopit Flag that determines whether chopping is executed or not
     * @return Compacted class name
     */
    public static final String compactClassName(String str, boolean chopit) {
        return compactClassName(str, "java.lang.", chopit);
    }

    private static final boolean is_digit(char ch) {
        return (ch >= '0') && (ch <= '9');
    }

    private static final boolean is_space(char ch) {
        return (ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n');
    }

    /**
     * @return `flag' with bit `i' set to 1
     */
    public static final int setBit(int flag, int i) {
        return flag | pow2(i);
    }

    /**
     * @return `flag' with bit `i' set to 0
     */
    public static final int clearBit(int flag, int i) {
        int bit = pow2(i);
        return (flag & bit) == 0 ? flag : flag ^ bit;
    }

    /**
     * @return true, if bit `i' in `flag' is set
     */
    public static final boolean isSet(int flag, int i) {
        return (flag & pow2(i)) != 0;
    }

    /**
     * Converts string containing the method return and argument types
     * to a byte code method signature.
     *
     * @param  ret Return type of method
     * @param  argv Types of method arguments
     * @return Byte code representation of method signature
     */
    public final static String methodTypeToSignature(String ret, String[] argv) throws ClassFormatException {
        StringBuffer buf = new StringBuffer("(");
        String str;

        if (argv != null)
            for (int i = 0; i < argv.length; i++) {
                str = getSignature(argv[i]);

                if (str.endsWith("V")) // void can't be a method argument
                    throw new ClassFormatException("Invalid type: " + argv[i]);

                buf.append(str);
            }

        str = getSignature(ret);

        buf.append(")" + str);

        return buf.toString();
    }

    /**
     * @param  signature    Method signature
     * @return Array of argument types
     * @throws  ClassFormatException
     */
    public static final String[] methodSignatureArgumentTypes(String signature) throws ClassFormatException {
        return methodSignatureArgumentTypes(signature, true);
    }

    /**
     * @param  signature    Method signature
     * @param chopit Shorten class names ?
     * @return Array of argument types
     * @throws  ClassFormatException
     */
    public static final String[] methodSignatureArgumentTypes(String signature, boolean chopit) throws ClassFormatException {
        ArrayList vec = new ArrayList();
        int index;
        String[] types;

        try { // Read all declarations between for `(' and `)'
            if (signature.charAt(0) != '(')
                throw new ClassFormatException("Invalid method signature: " + signature);

            index = 1; // current string position

            while (signature.charAt(index) != ')') {
                vec.add(signatureToString(signature.substring(index), chopit));
                index += consumed_chars; // update position
            }
        } catch (StringIndexOutOfBoundsException e) { // Should never occur
            throw new ClassFormatException("Invalid method signature: " + signature);
        }

        types = new String[vec.size()];
        vec.toArray(types);
        return types;
    }

    /**
     * @param  signature    Method signature
     * @return return type of method
     * @throws  ClassFormatException
     */
    public static final String methodSignatureReturnType(String signature) throws ClassFormatException {
        return methodSignatureReturnType(signature, true);
    }

    /**
     * @param  signature    Method signature
     * @param chopit Shorten class names ?
     * @return return type of method
     * @throws  ClassFormatException
     */
    public static final String methodSignatureReturnType(String signature, boolean chopit) throws ClassFormatException {
        int index;
        String type;

        try {
            // Read return type after `)'
            index = signature.lastIndexOf(')') + 1;
            type = signatureToString(signature.substring(index), chopit);
        } catch (StringIndexOutOfBoundsException e) { // Should never occur
            throw new ClassFormatException("Invalid method signature: " + signature);
        }

        return type;
    }

    /**
     * Converts method signature to string with all class names compacted.
     *
     * @param signature to convert
     * @param name of method
     * @param access flags of method
     * @return Human readable signature
     */
    public static final String methodSignatureToString(String signature, String name, String access) {
        return methodSignatureToString(signature, name, access, true);
    }

    public static final String methodSignatureToString(String signature, String name, String access, boolean chopit) {
        return methodSignatureToString(signature, name, access, chopit, null);
    }

    /**
     * A return type signature represents the return value from a method.
     * It is a series of bytes in the following grammar:
     *
     * <return_signature> ::= <field_type> | V
     *
     * The character V indicates that the method returns no value. Otherwise, the
     * signature indicates the type of the return value.
     * An argument signature represents an argument passed to a method:
     *
     * <argument_signature> ::= <field_type>
     *
     * A method signature represents the arguments that the method expects, and
     * the value that it returns.
     * <method_signature> ::= (<arguments_signature>) <return_signature>
     * <arguments_signature>::= <argument_signature>*
     *
     * This method converts such a string into a Java type declaration like
     * `void _main(String[])' and throws a `ClassFormatException' when the parsed
     * type is invalid.
     *
     * @param  signature    Method signature
     * @param  name         Method name
     * @param  access       Method access rights
     * @return Java type declaration
     * @throws  ClassFormatException
     */
    public static final String methodSignatureToString(String signature, String name, String access, boolean chopit, LocalVariableTable vars) throws ClassFormatException {
        StringBuffer buf = new StringBuffer("(");
        String type;
        int index;
        int var_index = (access.indexOf("static") >= 0) ? 0 : 1;

        try { // Read all declarations between for `(' and `)'
            if (signature.charAt(0) != '(')
                throw new ClassFormatException("Invalid method signature: " + signature);

            index = 1; // current string position

            while (signature.charAt(index) != ')') {
                String param_type = signatureToString(signature.substring(index), chopit);
                buf.append(param_type);

                if (vars != null) {
                    LocalVariable l = vars.getLocalVariable(var_index);

                    if (l != null)
                        buf.append(" " + l.getName());
                } else
                    buf.append(" arg" + var_index);

                if ("double".equals(param_type) || "long".equals(param_type))
                    var_index += 2;
                else
                    var_index++;

                buf.append(", ");
                index += consumed_chars; // update position
            }

            index++; // update position

            // Read return type after `)'
            type = signatureToString(signature.substring(index), chopit);

        } catch (StringIndexOutOfBoundsException e) { // Should never occur
            throw new ClassFormatException("Invalid method signature: " + signature);
        }

        if (buf.length() > 1) // Tack off the extra ", "
            buf.setLength(buf.length() - 2);

        buf.append(")");

        return access + ((access.length() > 0) ? " " : "") + // May be an empty string
        type + " " + name + buf.toString();
    }

    // Guess what this does
    private static final int pow2(int n) {
        return 1 << n;
    }

    /**
     * Replace all occurences of <em>old</em> in <em>str</em> with <em>new</em>.
     *
     * @param str String to permute
     * @param old String to be replaced
     * @param new Replacement string
     * @return new String object
     */
    public static final String replace(String str, String old, String new_) {
        int index, old_index;
        StringBuffer buf = new StringBuffer();

        try {
            if ((index = str.indexOf(old)) != -1) { // `old' found in str
                old_index = 0; // String start offset

                // While we have something to replace
                while ((index = str.indexOf(old, old_index)) != -1) {
                    buf.append(str.substring(old_index, index)); // append prefix
                    buf.append(new_); // append replacement

                    old_index = index + old.length(); // Skip `old'.length chars
                }

                buf.append(str.substring(old_index)); // append rest of string
                str = buf.toString();
            }
        } catch (StringIndexOutOfBoundsException e) { // Should not occur
            System.err.println(e);
        }

        return str;
    }

    /**
     * Converts signature to string with all class names compacted.
     *
     * @param signature to convert
     * @return Human readable signature
     */
    public static final String signatureToString(String signature) {
        return signatureToString(signature, true);
    }

    /**
     * The field signature represents the value of an argument to a function or
     * the value of a variable. It is a series of bytes generated by the
     * following grammar:
     *
     * <PRE>
     * <field_signature> ::= <field_type>
     * <field_type>      ::= <base_type>|<object_type>|<array_type>
     * <base_type>       ::= B|C|D|F|I|J|S|Z
     * <object_type>     ::= L<fullclassname>;
     * <array_type>      ::= [<field_type>
     *
     * The meaning of the base types is as follows:
     * B byte signed byte
     * C char character
     * D double double precision IEEE float
     * F float single precision IEEE float
     * I int integer
     * J long long integer
     * L<fullclassname>; ... an object of the given class
     * S short signed short
     * Z boolean true or false
     * [<field sig> ... array
     * </PRE>
     *
     * This method converts this string into a Java type declaration such as
     * `String[]' and throws a `ClassFormatException' when the parsed type is
     * invalid.
     *
     * @param  signature  Class signature
     * @param chopit Flag that determines whether chopping is executed or not
     * @return Java type declaration
     * @throws ClassFormatException
     */
    public static final String signatureToString(String signature, boolean chopit) {
        consumed_chars = 1; // This is the default, read just one char like `B'

        try {
            switch (signature.charAt(0)) {
                case 'B':
                    return "byte";
                case 'C':
                    return "char";
                case 'D':
                    return "double";
                case 'F':
                    return "float";
                case 'I':
                    return "int";
                case 'J':
                    return "long";

                case 'L': { // Full class name
                    int index = signature.indexOf(';'); // Look for closing `;'

                    if (index < 0)
                        throw new ClassFormatException("Invalid signature: " + signature);

                    consumed_chars = index + 1; // "Lblabla;" `L' and `;' are removed

                    return compactClassName(signature.substring(1, index), chopit);
                }

                case 'S':
                    return "short";
                case 'Z':
                    return "boolean";

                case '[': { // Array declaration
                    int n;
                    StringBuffer buf, brackets;
                    String type;
                    char ch;
                    int consumed_chars; // Shadows global var

                    brackets = new StringBuffer(); // Accumulate []'s

                    // Count opening brackets and look for optional size argument
                    for (n = 0; signature.charAt(n) == '['; n++)
                        brackets.append("[]");

                    consumed_chars = n; // Remember value

                    // The rest of the string denotes a `<field_type>'
                    type = signatureToString(signature.substring(n), chopit);

                    Utility.consumed_chars += consumed_chars;
                    return type + brackets.toString();
                }

                case 'V':
                    return "void";

                default:
                    throw new ClassFormatException("Invalid signature: `" + signature + "'");
            }
        } catch (StringIndexOutOfBoundsException e) { // Should never occur
            throw new ClassFormatException("Invalid signature: " + e + ":" + signature);
        }
    }

    /** Parse Java type such as "char", or "java.lang.String[]" and return the
     * signature in byte code format, e.g. "C" or "[Ljava/lang/String;" respectively.
     *
     * @param  type Java type
     * @return byte code signature
     */
    public static String getSignature(String type) {
        StringBuffer buf = new StringBuffer();
        char[] chars = type.toCharArray();
        boolean char_found = false, delim = false;
        int index = -1;

        loop: for (int i = 0; i < chars.length; i++) {
            switch (chars[i]) {
                case ' ':
                case '\t':
                case '\n':
                case '\r':
                case '\f':
                    if (char_found)
                        delim = true;
                    break;

                case '[':
                    if (!char_found)
                        throw new RuntimeException("Illegal type: " + type);

                    index = i;
                    break loop;

                default:
                    char_found = true;
                    if (!delim)
                        buf.append(chars[i]);
            }
        }

        int brackets = 0;

        if (index > 0)
            brackets = countBrackets(type.substring(index));

        type = buf.toString();
        buf.setLength(0);

        for (int i = 0; i < brackets; i++)
            buf.append('[');

        boolean found = false;

        for (int i = Constants.T_BOOLEAN; (i <= Constants.T_VOID) && !found; i++) {
            if (Constants.TYPE_NAMES[i].equals(type)) {
                found = true;
                buf.append(Constants.SHORT_TYPE_NAMES[i]);
            }
        }

        if (!found) // Class name
            buf.append('L' + type.replace('.', '/') + ';');

        return buf.toString();
    }

    private static int countBrackets(String brackets) {
        char[] chars = brackets.toCharArray();
        int count = 0;
        boolean open = false;

        for (int i = 0; i < chars.length; i++) {
            switch (chars[i]) {
                case '[':
                    if (open)
                        throw new RuntimeException("Illegally nested brackets:" + brackets);
                    open = true;
                    break;

                case ']':
                    if (!open)
                        throw new RuntimeException("Illegally nested brackets:" + brackets);
                    open = false;
                    count++;
                    break;

                default:
                    // Don't care
            }
        }

        if (open)
            throw new RuntimeException("Illegally nested brackets:" + brackets);

        return count;
    }

    /**
     * Return type of method signature as a byte value as defined in <em>Constants</em>
     *
     * @param  signature in format described above
     * @return type of method signature
     * @see    Constants
     */
    public static final byte typeOfMethodSignature(String signature) throws ClassFormatException {
        int index;

        try {
            if (signature.charAt(0) != '(')
                throw new ClassFormatException("Invalid method signature: " + signature);

            index = signature.lastIndexOf(')') + 1;
            return typeOfSignature(signature.substring(index));
        } catch (StringIndexOutOfBoundsException e) {
            throw new ClassFormatException("Invalid method signature: " + signature);
        }
    }

    /**
     * Return type of signature as a byte value as defined in <em>Constants</em>
     *
     * @param  signature in format described above
     * @return type of signature
     * @see    Constants
     */
    public static final byte typeOfSignature(String signature) throws ClassFormatException {
        try {
            switch (signature.charAt(0)) {
                case 'B':
                    return Constants.T_BYTE;
                case 'C':
                    return Constants.T_CHAR;
                case 'D':
                    return Constants.T_DOUBLE;
                case 'F':
                    return Constants.T_FLOAT;
                case 'I':
                    return Constants.T_INT;
                case 'J':
                    return Constants.T_LONG;
                case 'L':
                    return Constants.T_REFERENCE;
                case '[':
                    return Constants.T_ARRAY;
                case 'V':
                    return Constants.T_VOID;
                case 'Z':
                    return Constants.T_BOOLEAN;
                case 'S':
                    return Constants.T_SHORT;
                default:
                    throw new ClassFormatException("Invalid method signature: " + signature);
            }
        } catch (StringIndexOutOfBoundsException e) {
            throw new ClassFormatException("Invalid method signature: " + signature);
        }
    }

    /** Map opcode names to opcode numbers. E.g., return Constants.ALOAD for "aload"
     */
    public static short searchOpcode(String name) {
        name = name.toLowerCase();

        for (short i = 0; i < Constants.OPCODE_NAMES.length; i++)
            if (Constants.OPCODE_NAMES[i].equals(name))
                return i;

        return -1;
    }

    /**
     * Convert (signed) byte to (unsigned) short value, i.e., all negative
     * values become positive.
     */
    private static final short byteToShort(byte b) {
        return (b < 0) ? (short) (256 + b) : (short) b;
    }

    /** Convert bytes into hexidecimal string
     *
     * @return bytes as hexidecimal string, e.g. 00 FA 12 ...
     */
    public static final String toHexString(byte[] bytes) {
        StringBuffer buf = new StringBuffer();

        for (int i = 0; i < bytes.length; i++) {
            short b = byteToShort(bytes[i]);
            String hex = Integer.toString(b, 0x10);

            if (b < 0x10) // just one digit, prepend '0'
                buf.append('0');

            buf.append(hex);

            if (i < bytes.length - 1)
                buf.append(' ');
        }

        return buf.toString();
    }

    /**
     * Return a string for an integer justified left or right and filled up with
     * `fill' characters if necessary.
     *
     * @param i integer to format
     * @param length length of desired string
     * @param left_justify format left or right
     * @param fill fill character
     * @return formatted int
     */
    public static final String format(int i, int length, boolean left_justify, char fill) {
        return fillup(Integer.toString(i), length, left_justify, fill);
    }

    /**
     * Fillup char with up to length characters with char `fill' and justify it left or right.
     *
     * @param str string to format
     * @param length length of desired string
     * @param left_justify format left or right
     * @param fill fill character
     * @return formatted string
     */
    public static final String fillup(String str, int length, boolean left_justify, char fill) {
        int len = length - str.length();
        char[] buf = new char[(len < 0) ? 0 : len];

        for (int j = 0; j < buf.length; j++)
            buf[j] = fill;

        if (left_justify)
            return str + new String(buf);
        else
            return new String(buf) + str;
    }

    static final boolean equals(byte[] a, byte[] b) {
        int size;

        if ((size = a.length) != b.length)
            return false;

        for (int i = 0; i < size; i++)
            if (a[i] != b[i])
                return false;

        return true;
    }

    public static final void printArray(PrintStream out, Object[] obj) {
        out.println(printArray(obj, true));
    }

    public static final void printArray(PrintWriter out, Object[] obj) {
        out.println(printArray(obj, true));
    }

    public static final String printArray(Object[] obj) {
        return printArray(obj, true);
    }

    public static final String printArray(Object[] obj, boolean braces) {
        return printArray(obj, braces, false);
    }

    public static final String printArray(Object[] obj, boolean braces, boolean quote) {
        if (obj == null)
            return null;

        StringBuffer buf = new StringBuffer();
        if (braces)
            buf.append('{');

        for (int i = 0; i < obj.length; i++) {
            if (obj[i] != null) {
                buf.append((quote ? "\"" : "") + obj[i].toString() + (quote ? "\"" : ""));
            } else {
                buf.append("null");
            }

            if (i < obj.length - 1) {
                buf.append(", ");
            }
        }

        if (braces)
            buf.append('}');

        return buf.toString();
    }

    /** @return true, if character is one of (a, ... z, A, ... Z, 0, ... 9, _)
     */
    public static boolean isJavaIdentifierPart(char ch) {
        return ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || ((ch >= '0') && (ch <= '9')) || (ch == '_');
    }

    /** Encode byte array it into Java identifier string, i.e., a string
     * that only contains the following characters: (a, ... z, A, ... Z,
     * 0, ... 9, _, $).  The encoding algorithm itself is not too
     * clever: if the current byte's ASCII value already is a valid Java
     * identifier part, leave it as it is. Otherwise it writes the
     * escape character($) followed by <p><ul><li> the ASCII value as a
     * hexadecimal string, if the value is not in the range
     * 200..247</li> <li>a Java identifier char not used in a lowercase
     * hexadecimal string, if the value is in the range
     * 200..247</li><ul></p>
     *
     * <p>This operation inflates the original byte array by roughly 40-50%</p>
     *
     * @param bytes the byte array to convert
     * @param compress use gzip to minimize string
     */
    public static String encode(byte[] bytes, boolean compress) throws IOException {
        if (compress) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gos = new GZIPOutputStream(baos);

            gos.write(bytes, 0, bytes.length);
            gos.close();
            baos.close();

            bytes = baos.toByteArray();
        }

        CharArrayWriter caw = new CharArrayWriter();
        JavaWriter jw = new JavaWriter(caw);

        for (int i = 0; i < bytes.length; i++) {
            int in = bytes[i] & 0x000000ff; // Normalize to unsigned
            jw.write(in);
        }

        return caw.toString();
    }

    /** Decode a string back to a byte array.
     *
     * @param bytes the byte array to convert
     * @param uncompress use gzip to uncompress the stream of bytes
     */
    public static byte[] decode(String s, boolean uncompress) throws IOException {
        char[] chars = s.toCharArray();

        CharArrayReader car = new CharArrayReader(chars);
        JavaReader jr = new JavaReader(car);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int ch;

        while ((ch = jr.read()) >= 0) {
            bos.write(ch);
        }

        bos.close();
        car.close();
        jr.close();

        byte[] bytes = bos.toByteArray();

        if (uncompress) {
            GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(bytes));

            byte[] tmp = new byte[bytes.length * 3]; // Rough estimate
            int count = 0;
            int b;

            while ((b = gis.read()) >= 0)
                tmp[count++] = (byte) b;

            bytes = new byte[count];
            System.arraycopy(tmp, 0, bytes, 0, count);
        }

        return bytes;
    }

    // A-Z, g-z, _, $
    private static final int FREE_CHARS = 48;
    private static int[] CHAR_MAP = new int[FREE_CHARS];
    private static int[] MAP_CHAR = new int[256]; // Reverse map
    private static final char ESCAPE_CHAR = '$';

    static {
        int j = 0, k = 0;
        for (int i = 'A'; i <= 'Z'; i++) {
            CHAR_MAP[j] = i;
            MAP_CHAR[i] = j;
            j++;
        }

        for (int i = 'g'; i <= 'z'; i++) {
            CHAR_MAP[j] = i;
            MAP_CHAR[i] = j;
            j++;
        }

        CHAR_MAP[j] = '$';
        MAP_CHAR['$'] = j;
        j++;

        CHAR_MAP[j] = '_';
        MAP_CHAR['_'] = j;
    }

    /** Decode characters into bytes.
     * Used by <a href="Utility.html#decode(java.lang.String, boolean)">decode()</a>
     */
    private static class JavaReader extends FilterReader {
        public JavaReader(Reader in) {
            super(in);
        }

        public int read() throws IOException {
            int b = in.read();

            if (b != ESCAPE_CHAR) {
                return b;
            } else {
                int i = in.read();

                if (i < 0)
                    return -1;

                if (((i >= '0') && (i <= '9')) || ((i >= 'a') && (i <= 'f'))) { // Normal escape
                    int j = in.read();

                    if (j < 0)
                        return -1;

                    char[] tmp = { (char) i, (char) j };
                    int s = Integer.parseInt(new String(tmp), 16);

                    return s;
                } else { // Special escape
                    return MAP_CHAR[i];
                }
            }
        }

        public int read(char[] cbuf, int off, int len) throws IOException {
            for (int i = 0; i < len; i++)
                cbuf[off + i] = (char) read();

            return len;
        }
    }

    /** Encode bytes into valid java identifier characters.
     * Used by <a href="Utility.html#encode(byte[], boolean)">encode()</a>
     */
    private static class JavaWriter extends FilterWriter {
        public JavaWriter(Writer out) {
            super(out);
        }

        public void write(int b) throws IOException {
            if (isJavaIdentifierPart((char) b) && (b != ESCAPE_CHAR)) {
                out.write(b);
            } else {
                out.write(ESCAPE_CHAR); // Escape character

                // Special escape
                if (b >= 0 && b < FREE_CHARS) {
                    out.write(CHAR_MAP[b]);
                } else { // Normal escape
                    char[] tmp = Integer.toHexString(b).toCharArray();

                    if (tmp.length == 1) {
                        out.write('0');
                        out.write(tmp[0]);
                    } else {
                        out.write(tmp[0]);
                        out.write(tmp[1]);
                    }
                }
            }
        }

        public void write(char[] cbuf, int off, int len) throws IOException {
            for (int i = 0; i < len; i++)
                write(cbuf[off + i]);
        }

        public void write(String str, int off, int len) throws IOException {
            write(str.toCharArray(), off, len);
        }
    }

    /**
     * Escape all occurences of newline chars '\n', quotes \", etc.
     */
    public static final String convertString(String label) {
        char[] ch = label.toCharArray();
        StringBuffer buf = new StringBuffer();

        for (int i = 0; i < ch.length; i++) {
            switch (ch[i]) {
                case '\n':
                    buf.append("\\n");
                    break;
                case '\r':
                    buf.append("\\r");
                    break;
                case '\"':
                    buf.append("\\\"");
                    break;
                case '\'':
                    buf.append("\\'");
                    break;
                case '\\':
                    buf.append("\\\\");
                    break;
                default:
                    buf.append(ch[i]);
                    break;
            }
        }

        return buf.toString();
    }
}
